<?php
/// ------------
/// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
/// ------------
/// | Copyright (c) 2006-2012 http:///thinkphp.cn All rights reserved.
/// ------------
/// | Licensed ( http:///www.apache.org/licenses/LICENSE-2.0 )
/// ------------
/// | Author: liu21st <liu21st@gmail.com>
/// ------------
/// $Id: Model.class.php 2956 2012-05-25 08:14:26Z liu21st@gmail.com $

/**
 * ThinkPHP Model模型类
 * 实现了ORM和ActiveRecords模式
 * @category   Think
 * @package  Think
 * @subpackage  Core
 * @author    liu21st <liu21st@gmail.com>
 * @version   $Id: Model.class.php 2956 2012-05-25 08:14:26Z liu21st@gmail.com $
 */
class Model {
    /// 操作状态
    const MODEL_INSERT      =   1;      ///  插入模型数据
    const MODEL_UPDATE    =   2;      ///  更新模型数据
    const MODEL_BOTH      =   3;      ///  包含上面两种方式
    const MUST_VALIDATE         =   1;/// 必须验证
    const EXISTS_VAILIDATE      =   0;/// 表单存在字段则验证
    const VALUE_VAILIDATE       =   2;/// 表单值不为空则验证
    /// 当前使用的扩展模型
    private $_extModel =  null;
    /// 当前数据库操作对象
    protected $db = null;
    /// 主键名称
    protected $pk  = 'id';
    /// 数据表前缀
    protected $tablePrefix  =   '';
    /// 模型名称
    protected $name = '';
    /// 数据库名称
    protected $dbName  = '';
    /// 数据表名（不包含表前缀）
    protected $tableName = '';
    /// 实际数据表名（包含表前缀）
    protected $trueTableName ='';
    /// 最近错误信息
    protected $error = '';
     /// 最近错误信息
    protected $errorHistory = '';
    /// 是否表单验证错误
    public $errorStatus = 0;
    /// 字段信息
    protected $fields = array();
    /// 数据信息
    protected $data =   array();
     /// 数据信息
    protected $vdata =   array();
     /// 列表总记录数
    protected $total_record =   0;
    
    /// 查询表达式参数
    protected $options  =   array();
    protected $_validate       = array();  /// 自动验证定义
    protected $_moduleValidate = array();  /// 模块内自动验证定义
    public    $_valid_type     = '';  /// 验证类型
    protected $_auto           = array();  /// 自动完成定义
    protected $_map           = array();  /// 字段映射定义
    protected $_scope          = array();  /// 命名范围定义
    /// 是否自动检测数据表字段信息
    protected $autoCheckFields   =   true;
    /// 是否批处理验证
    protected $patchValidate   =  true;
    /// 链操作方法列表
    protected $methods = array('table','where','order','limit','page','alias','having','group','lock','distinct','auto','filter','validate');
    public $_module = '';
    public $_action = '';
    ///excel导入保存重复id
    protected $excel_ids	= '';
    public $valid_excel_unique_state 	= true;		/// 唯一是否验证

    /**
     * 架构函数
     * 取得DB类的实例对象 字段检查
     * @param string $name 模型名称
     * @param string $tablePrefix 表前缀
     * @param mixed $connection 数据库连接信息
     * @access public
     */
    public function __construct($name='',$tablePrefix='',$connection='') {
        /// 模型初始化
        $this->_initialize();
        /// 获取模型名称
        if(!empty($name)) {
            if(strpos($name,'.')) { /// 支持 数据库名.模型名的 定义
                list($this->dbName,$this->name) = explode('.',$name);
            }else{
                $this->name   =  $name;
            }
        }elseif(empty($this->name)){
            $this->name =   $this->getModelName();
        }
        /// 设置表前缀
        if(is_null($tablePrefix)) {/// 前缀为Null表示没有前缀
            $this->tablePrefix = '';
        }elseif('' != $tablePrefix) {
            $this->tablePrefix = $tablePrefix;
        }else{
            $this->tablePrefix = $this->tablePrefix?$this->tablePrefix:C('DB_PREFIX');
        }

        /// 数据库初始化操作
        /// 获取数据库操作对象
        /// 当前模型有独立的数据库连接信息
        $this->db(0,empty($this->connection)?$connection:$this->connection);
        /// 设置模块，操作值 
        $this->_module = MODULE_NAME;
        $this->_action = ACTION_NAME;
    }

    /**
     * 自动检测数据表信息
     * @access protected
     * @return void
     */
    protected function _checkTableInfo() {
        /// 如果不是Model类 自动记录数据表信息
        /// 只在第一次执行记录
        if(empty($this->fields)) {
            /// 如果数据表字段没有定义则自动获取
            if(C('DB_FIELDS_CACHE')) {
                $db   =  $this->dbName?$this->dbName:C('DB_NAME');
                $fields = F('_fields/'.strtolower($db.'.'.$this->name));
                if($fields) {
                    $version    =   C('DB_FIELD_VERISON');
                    if(empty($version) || $fields['_version']== $version) {
                        $this->fields   =   $fields;
                        return ;
                    }
                }
            }
            /// 每次都会读取数据表信息
            $this->flush();
        }
    }

    /**
     * 获取字段信息并缓存
     * @access public
     * @return void
     */
    public function flush() {
        /// 缓存不存在则查询数据表信息
        $this->db->setModel($this->name);
        $fields =   $this->db->getFields($this->getTableName());
        if(!$fields) { /// 无法获取字段信息
            return false;
        }
        $this->fields   =   array_keys($fields);
        $this->fields['_autoinc'] = false;
        foreach ($fields as $key=>$val){
            /// 记录字段类型
            $type[$key]    =   $val['type'];
            if($val['primary']) {
                $this->fields['_pk'] = $key;
                if($val['autoinc']) $this->fields['_autoinc']   =   true;
            }
        }
        /// 记录字段类型信息
        $this->fields['_type'] =  $type;
        if(C('DB_FIELD_VERISON')) $this->fields['_version'] =   C('DB_FIELD_VERISON');

        /// 2008-3-7 增加缓存开关控制
        if(C('DB_FIELDS_CACHE')){
            /// 永久缓存数据表信息
            $db   =  $this->dbName?$this->dbName:C('DB_NAME');
            F('_fields/'.strtolower($db.'.'.$this->name),$this->fields);
        }
    }

    /**
     * 动态切换扩展模型
     * @access public
     * @param string $type 模型类型名称
     * @param mixed $vars 要传入扩展模型的属性变量
     * @return Model
     */
    public function switchModel($type,$vars=array()) {
        $class = ucwords(strtolower($type)).'Model';
        if(!class_exists($class))
            throw_exception($class.L('_MODEL_NOT_EXIST_'));
        /// 实例化扩展模型
        $this->_extModel   = new $class($this->name);
        if(!empty($vars)) {
            /// 传入当前模型的属性到扩展模型
            foreach ($vars as $var)
                $this->_extModel->setProperty($var,$this->$var);
        }
        return $this->_extModel;
    }

    /**
     * 设置数据对象的值
     * @access public
     * @param string $name 名称
     * @param mixed $value 值
     * @return void
     */
    public function __set($name,$value) {
        /// 设置数据对象属性
        $this->data[$name]  =   $value;
    }

    /**
     * 获取数据对象的值
     * @access public
     * @param string $name 名称
     * @return mixed
     */
    public function __get($name) {
        return isset($this->data[$name])?$this->data[$name]:null;
    }

    /**
     * 检测数据对象的值
     * @access public
     * @param string $name 名称
     * @return boolean
     */
    public function __isset($name) {
        return isset($this->data[$name]);
    }

    /**
     * 销毁数据对象的值
     * @access public
     * @param string $name 名称
     * @return void
     */
    public function __unset($name) {
        unset($this->data[$name]);
    }

    /**
     * 利用__call方法实现一些特殊的Model方法
     * @access public
     * @param string $method 方法名称
     * @param array $args 调用参数
     * @return mixed
     */
    public function __call($method,$args) {
        if(in_array(strtolower($method),$this->methods,true)) {
            /// 连贯操作的实现
            if ($method=='page' && empty($args[0])) {
            	$listRows = C('line_number') ? C('line_number') : 20;
		        $totalPages = ceil($this->total_record/$listRows);     //总页数
		        $nowPage    = !empty($_REQUEST[C('VAR_PAGE')])?intval($_REQUEST[C('VAR_PAGE')]):1; 
		        if($nowPage>$totalPages) {
		            $nowPage = $totalPages;
		        }
            	$args[0] = $nowPage;
            }
            $this->options[strtolower($method)] = $args[0];
            return $this;
        }elseif (strtolower($method)=='exists'){
        	$this->options[strtolower($method)][] = $args[0];
        	return $this;
        }elseif(in_array(strtolower($method),array('count','sum','min','max','avg'),true)){
            /// 统计查询的实现
            $field =  isset($args[0])?$args[0]:'*';
            return $this->getField(strtoupper($method).'('.$field.') AS tp_'.$method);
        }elseif(strtolower(substr($method,0,5))=='getby') {
            /// 根据某个字段获取记录
            $field   =   parse_name(substr($method,5));
            $where[$field] =  $args[0];
            return $this->where($where)->find();
        }elseif(strtolower(substr($method,0,10))=='getfieldby') {
            /// 根据某个字段获取记录的某个值
            $name   =   parse_name(substr($method,10));
            $where[$name] =$args[0];
            return $this->where($where)->getField($args[1]);
        }elseif(isset($this->_scope[$method])){/// 命名范围的单独调用支持
            return $this->scope($method,$args[0]);
        }else{
            throw_exception(__CLASS__.':'.$method.L('_METHOD_NOT_EXIST_'));
            return;
        }
    }
    /// 回调方法 初始化模型
    protected function _initialize() {}

    /**
     * 对保存到数据库的数据进行处理
     * @access protected
     * @param mixed $data 要操作的数据
     * @return boolean
     */
     protected function _facade($data) {
        /// 检查非数据字段
        if(!empty($this->fields)) {
            foreach ($data as $key=>$val){
                if(!in_array($key,$this->fields,true)){
                    unset($data[$key]);
                }elseif(is_scalar($val)) {
                    /// 字段类型检查
                    $this->_parseType($data,$key);
                }
            }
        }
        /// 安全过滤
        if(!empty($this->options['filter'])) {
            $data = array_map($this->options['filter'],$data);
            unset($this->options['filter']);
        }
        $this->_before_write($data);
        return $data;
     }

    /// 写入数据前的回调方法 包括新增和更新
    protected function _before_write(&$data) {}

    /**
     * 新增数据
     * @access public
     * @param mixed $data 数据
     * @param array $options 表达式
     * @param boolean $replace 是否replace
     * @return mixed
     */
    public function add($data='',$options=array(),$replace=false) {
        if(empty($data)) {
            /// 没有传递数据，获取当前数据对象的值
            if(!empty($this->data)) {
                $data    =   $this->data;
                /// 重置数据
                $this->data = array();
            }else{
                $this->error = L('_DATA_TYPE_INVALID_');
                return false;
            }
        }
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        /// 数据处理
        $data = $this->_facade($data);
        if(false === $this->_before_insert($data,$options)) {
            return false;
        } 
        
        if(in_array('add_user', $this->fields,true)) { ///lkh 新增用户
        	$data['add_user'] = USER_ID;
        }  
        if(in_array('last_time', $this->fields,true)) { ///lkh 新增用户
        	$data['last_time'] = date("Y-m-d H:i:s");
        }  
        $data	=	$this->setFieldDate($data);
        
        /// 写入数据到数据库
///        		for ($i = 1; $i <= 10000; $i++) {  
        $result = $this->db->insert($data,$options,$replace);
///        		}
        if(false !== $result ) {
            $insertId   =   $this->getLastInsID();
            if($insertId) {
                /// 自增主键返回插入ID
                $data[$this->getPk()]  = $insertId;
                $this->_after_insert($data,$options);
                return $insertId;
            }
            $this->_after_insert($data,$options);
        }
        return $result;
    }
    
    /**
     * 格式化要插入DB前的日期格式
     *
     * @param unknown_type $data
     */
    public function setFieldDate(&$data){
    	if (C('digital_format')=='eur'){ 
	    	$tableDate	=	S('create_table_about_date');  
	    	if (!is_array($tableDate[$this->trueTableName])){ return $data; }   
	    	foreach ((array)$tableDate[$this->trueTableName] as $key => $value) {    
	    		isset($data[$value['Field']])	&&	$data[$value['Field']]	=	formatDate($data[$value['Field']]);   
	    	}  
	    	return $data;
    	}else{
    		return $data;
    	}
    }
    
    /// 插入数据前的回调方法
    protected function _before_insert(&$data,$options) {}
    /// 插入成功后的回调方法
    protected function _after_insert($data,$options) {}

    public function addAll($dataList,$options=array(),$replace=false){
        if(empty($dataList)) {
            $this->error = L('_DATA_TYPE_INVALID_');
            return false;
        }
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        /// 数据处理
        foreach ($dataList as $key=>$data){
            $dataList[$key] = $this->_facade($data);
        }
        /// 写入数据到数据库
        $result = $this->db->insertAll($dataList,$options,$replace);
        if(false !== $result ) {
            $insertId   =   $this->getLastInsID();
            if($insertId) {
                return $insertId;
            }
        }
        return $result;
    }

    /**
     * 通过Select方式添加记录
     * @access public
     * @param string $fields 要插入的数据表字段名
     * @param string $table 要插入的数据表名
     * @param array $options 表达式
     * @return boolean
     */
    public function selectAdd($fields='',$table='',$options=array()) {
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        /// 写入数据到数据库
        if(false === $result = $this->db->selectInsert($fields?$fields:$options['field'],$table?$table:$this->getTableName(),$options)){
            /// 数据库插入操作失败
            $this->error = L('_OPERATION_WRONG_');
            return false;
        }else {
            /// 插入成功
            return $result;
        }
    }

    /**
     * 保存数据
     * @access public
     * @param mixed $data 数据
     * @param array $options 表达式
     * @return boolean
     */
    public function save($data='',$options=array()) {
        if(empty($data)) {
            /// 没有传递数据，获取当前数据对象的值
            if(!empty($this->data)) {
                $data    =   $this->data;
                /// 重置数据
                $this->data = array();
            }else{
                $this->error = L('_DATA_TYPE_INVALID_');
                return false;
            }
        }
        /// 数据处理
        $data = $this->_facade($data);
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        if(false === $this->_before_update($data,$options)) {
            return false;
        }
        if(!isset($options['where']) ) {
            /// 如果存在主键数据 则自动作为更新条件
            if(isset($data[$this->getPk()])) {
                $pk   =  $this->getPk();
                $where[$pk]   =  $data[$pk];
                $options['where']  =  $where;
                $pkValue = $data[$pk];
                unset($data[$pk]);
            }else{
                /// 如果没有任何更新条件则不执行
                $this->error = L('_OPERATION_WRONG_');
                return false;
            }
        }
        if(in_array('edit_user', $this->fields,true)) { /// lkh
        	$data['edit_user'] = USER_ID;
        }
        if(in_array('last_time', $this->fields,true)) { ///lkh 新增用户
        	$data['last_time'] = date("Y-m-d H:i:s");
        }  
        $data	=	$this->setFieldDate($data); 
        $result = $this->db->update($data,$options);
        if(false !== $result) {
            if(isset($pkValue)) $data[$pk]   =  $pkValue;
            $this->_after_update($data,$options);
        }
        return $result;
    }
    /// 更新数据前的回调方法
    protected function _before_update(&$data,$options) {
    	/// 检查记录是否存在
    	if(isset($data[$this->getPk()])) {
    		if(in_array(C('LOCK_NAME'),$this->fields,true)){
    			$rs = $this->field(C('LOCK_NAME'))->find($data[$this->getPk()]);
		    	if (!isset($rs[C('LOCK_NAME')])) {
		    		throw_json(L('_RECORD_NULL_'));
		    	}
		    	if(false===$this->checkLockVersion($data,$rs)){
		    		throw_json($this->error);
		    	}
    		}else {
    			$count = $this->where($this->getPk().'='.$data[$this->getPk()])->count();
		    	if ($count<=0) {
		    		throw_json(L('_RECORD_NULL_'));
		    	}
    		}
    		
    	}
    	
    }
    /// 更新成功后的回调方法
    protected function _after_update($data,$options) {}

    /**
     * 删除数据
     * @access public
     * @param mixed $options 表达式
     * @return mixed
     */
    public function delete($options=array()) {
        if(empty($options) && empty($this->options['where'])) {
            /// 如果删除条件为空 则删除当前数据对象所对应的记录
            if(!empty($this->data) && isset($this->data[$this->getPk()]))
                return $this->delete($this->data[$this->getPk()]);
            else
                return false;
        }
        if(is_numeric($options)  || is_string($options)) {
            /// 根据主键删除记录
            $pk   =  $this->getPk();
            if(strpos($options,',')) {
                $where[$pk]   =  array('IN', $options);
            }else{
                $where[$pk]   =  $options;
                $pkValue = $options;
            }
            $options =  array();
            $options['where'] =  $where;
        }
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        $result=    $this->db->delete($options);
        if(false !== $result) {
            $data = array();
            if(isset($pkValue)) $data[$pk]   =  $pkValue;
            $this->_after_delete($data,$options);
        }
        if ($result==0 && $where[$pk]) {
        	throw_json(L('_DELETE_NULL_'));
        }
        /// 返回删除记录个数
        return $result;
    }
    /// 删除成功后的回调方法
    protected function _after_delete($data,$options) {}

    /**
     * 查询数据集
     * @access public
     * @param array $options 表达式参数
     * @return mixed
     */
    public function select($options=array()) {
        if(is_string($options) || is_numeric($options)) {
            /// 根据主键查询
            $pk   =  $this->getPk();
            if(strpos($options,',')) {
                $where[$pk] =  array('IN',$options);
            }else{
                $where[$pk]   =  $options;
            }
            $options =  array();
            $options['where'] =  $where;
        }elseif(false === $options){ /// 用于子查询 不查询只返回SQL
            $options =  array();
            /// 分析表达式
            $options =  $this->_parseOptions($options);
            return  '( '.$this->db->buildSelectSql($options).' )';
        }
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        $resultSet = $this->db->select($options);
        if(false === $resultSet) {
            return false;
        }
        if(empty($resultSet)) { /// 查询结果为空
            return null;
        }
        $this->_after_select($resultSet,$options);
        return $resultSet;
    }
    
    /// 传递分页信息至模板界面
    public function setPage($count){
    	$this->total_record = $count;
    	_page($count);
    }
    
    /// 对select返回结果进行拆分字条串，只支持id单字段
    public function selectIds($options=array()) {
    	$result = $this->select($options);
    	if (empty($result)) {
    		return '(0)';
    	}
    	foreach ((array)$result as $value) {
			$ids[] = $value['id'];
		}
		return '( '.implode(',',$ids).' )';
    }
    
    
    /// 查询成功后的回调方法
    protected function _after_select(&$resultSet,$options) {}

    /**
     * 生成查询SQL 可用于子查询
     * @access public
     * @param array $options 表达式参数
     * @return string
     */
    public function buildSql($options=array()) {
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        return  '( '.$this->db->buildSelectSql($options).' )';
    }

    /**
     * 分析表达式
     * @access proteced
     * @param array $options 表达式参数
     * @return array
     */
    protected function _parseOptions($options=array()) {
        if(is_array($options))
            $options =  array_merge($this->options,$options);
        /// 查询过后清空sql表达式组装 避免影响下次查询
        $this->options  =   array();
        if(!isset($options['table']))
            /// 自动获取表名
            $options['table'] =$this->getTableName();
        if(!empty($options['alias'])) {
            $options['table']   .= ' '.$options['alias'];
        }
        /// 记录操作的模型名称
        $options['model'] =  $this->name;
        /// 字段类型验证
        if(isset($options['where']) && is_array($options['where']) && !empty($this->fields)) {
            /// 对数组查询条件进行字段类型检查
            foreach ($options['where'] as $key=>$val){
                if(in_array($key,$this->fields,true)){
                    if(is_scalar($val)) {
                        $this->_parseType($options['where'],$key);
                    }
                }elseif('_' != substr($key,0,1) && false === strpos($key,'.')){
                    unset($options['where'][$key]);
                }
            }
        }
        /// 表达式过滤
        $this->_options_filter($options);
        return $options;
    }
    /// 表达式过滤回调方法
    protected function _options_filter(&$options) {}

    /**
     * 数据类型检测
     * @access protected
     * @param mixed $data 数据
     * @param string $key 字段名
     * @return void
     */
    protected function _parseType(&$data,$key) {
        $fieldType = strtolower($this->fields['_type'][$key]);
        if(false === strpos($fieldType,'bigint') && false !== strpos($fieldType,'int')) {
            $data[$key]   =  intval($data[$key]);
        }elseif(false !== strpos($fieldType,'float') || false !== strpos($fieldType,'double')){
            $data[$key]   =  floatval($data[$key]);
        }elseif(false !== strpos($fieldType,'bool')){
            $data[$key]   =  (bool)$data[$key];
        }
    }

    /**
     * 查询数据
     * @access public
     * @param mixed $options 表达式参数
     * @return mixed
     */
    public function find($options=array()) {
        if(is_numeric($options) || is_string($options)) {
            $where[$this->getPk()] =$options;
            $options = array();
            $options['where'] = $where;
        }
        /// 总是查找一条记录
        $options['limit'] = 1;
        /// 分析表达式
        $options =  $this->_parseOptions($options);
        $resultSet = $this->db->select($options);
        if(false === $resultSet) {
            return false;
        }
        if(empty($resultSet)) {/// 查询结果为空
            return null;
        }
        $this->data = $resultSet[0];
        $this->_after_find($this->data,$options);
        return $this->data;
    }
    /// 查询成功的回调方法
    protected function _after_find(&$result,$options) {}

    /**
     * 处理字段映射
     * @access public
     * @param array $data 当前数据
     * @param integer $type 类型 0 写入 1 读取
     * @return array
     */
    public function parseFieldsMap($data,$type=1) {
        /// 检查字段映射
        if(!empty($this->_map)) {
            foreach ($this->_map as $key=>$val){
                if($type==1) { /// 读取
                    if(isset($data[$val])) {
                        $data[$key] =   $data[$val];
                        unset($data[$val]);
                    }
                }else{
                    if(isset($data[$key])) {
                        $data[$val] =   $data[$key];
                        unset($data[$key]);
                    }
                }
            }
        }
        return $data;
    }

    /**
     * 设置记录的某个字段值
     * 支持使用数据库字段和方法
     * @access public
     * @param string|array $field  字段名
     * @param string $value  字段值
     * @return boolean
     */
    public function setField($field,$value='') {
        if(is_array($field)) {
            $data = $field;
        }else{
            $data[$field]   =  $value;
        }
        return $this->save($data);
    }

    /**
     * 字段值增长
     * @access public
     * @param string $field  字段名
     * @param integer $step  增长值
     * @return boolean
     */
    public function setInc($field,$step=1) {
        return $this->setField($field,array('exp',$field.'+'.$step));
    }

    /**
     * 字段值减少
     * @access public
     * @param string $field  字段名
     * @param integer $step  减少值
     * @return boolean
     */
    public function setDec($field,$step=1) {
        return $this->setField($field,array('exp',$field.'-'.$step));
    }

    /**
     * 获取一条记录的某个字段值
     * @access public
     * @param string $field  字段名
     * @param string $spea  字段数据间隔符号 NULL返回数组
     * @return mixed
     */
    public function getField($field,$sepa=null) {
        $options['field']    =  $field;
        $options =  $this->_parseOptions($options);
        $field  =   trim($field);
        if(strpos($field,',')) { /// 多字段
            $resultSet = $this->db->select($options);
            if(!empty($resultSet)) {
                $_field = explode(',', $field);
                $field  = array_keys($resultSet[0]);
                $move   =  $_field[0]==$_field[1]?false:true;
                $key =  array_shift($field);
                $key2 = array_shift($field);
                $cols   =   array();
                $count  =   count($_field);
                foreach ($resultSet as $result){
                    $name   =  $result[$key];
                    if($move) { /// 删除键值记录
                        unset($result[$key]);
                    }
                    if(2==$count) {
                        $cols[$name]   =  $result[$key2];
                    }else{
                        $cols[$name]   =  is_null($sepa)?$result:implode($sepa,$result);
                    }
                }
                return $cols;
            }
        }else{   /// 查找一条记录
            /// 返回数据个数
            if(true !== $sepa) {/// 当sepa指定为true的时候 返回所有数据
                $options['limit']   =   is_numeric($sepa)?$sepa:1;
            }
            $result = $this->db->select($options);
            if(!empty($result)) {
                if(true !== $sepa && 1==$options['limit']){ 
                	return reset($result[0]);
                } 
                foreach ($result as $val){
                    $array[]    =   $val[$field];
                }
                return $array;
            }
        }
        return null;
    }

    /**
     * 创建数据对象 但不保存到数据库
     * @access public
     * @param mixed $data 创建数据
     * @param string $type 状态
     * @return mixed
     */
     public function create($data='',$type='',$tokenAndValid=true) {
        /// 如果没有传值默认取POST数据
        if(empty($data)) {
            $data    =   $_POST;
        }elseif(is_object($data)){
            $data   =   get_object_vars($data);
        }
        /// 验证数据
        if(empty($data) || !is_array($data)) {
            $this->error = L('_DATA_TYPE_INVALID_');
            return false;
        }

        /// 检查字段映射
        $data = $this->parseFieldsMap($data,0);

        /// 状态
        $this->_valid_type	= $type = $type?$type:(!empty($data[$this->getPk()])?self::MODEL_UPDATE:self::MODEL_INSERT);
		
        /// 检测提交字段的合法性
        if(isset($this->options['field'])) { /// $this->field('field1,field2...')->create()
            $fields =   $this->options['field'];
            unset($this->options['field']);
        }elseif($type == self::MODEL_INSERT && isset($this->insert_fields)) {
            $fields =   $this->insert_fields;
        }elseif($type == self::MODEL_UPDATE && isset($this->update_fields)) {
            $fields =   $this->update_fields;
        }
        if(isset($fields)) {
            if(is_string($fields)) {
                $fields =   explode(',',$fields);
            }
            foreach ($data as $key=>$val){
                if(!in_array($key,$fields)) {
                    unset($data[$key]);
                }
            }
        }  
        
        if ($tokenAndValid==true){
	        	///验证中数据特殊处理
	        $this->vdata	=	$data;
	        /// 数据自动验证
	        if(!$this->autoValidation($data,$type)) return false; 
	        ///验证中数据特殊处理
	        $data	=	$this->vdata;  
	       
	        /// 表单令牌验证
	        if(C('TOKEN_ON') && !$this->autoCheckToken($data)) {
	            $this->error = L('_TOKEN_ERROR_');
	            return false;
	        }       	
        }

        
        /// 验证完成生成数据对象
        if($this->autoCheckFields) { /// 开启字段检测 则过滤非法字段数据 
            $fields 	=   $this->getDbFields();
            $formatdate	=	S('dd_config_format_date'); 
            ///关联插入
            if (is_array($this->_link) && count($this->_link)>0){      
            	foreach ($data as $key=>$val){  
            		///判断是否是关联信息的下标 如果是即过滤删除
            		if (!array_key_exists($key,$this->_link)){    
            			if(!in_array($key,$fields) ) {
	                    unset($data[$key]);
		                }elseif(MAGIC_QUOTES_GPC && is_string($val)){
		                    $data[$key] =   stripslashes($val);
		                }
            		}else{
            			///如果关联信息为空主动删除 避免插入到主表当中!
            			if (empty($data[$key])){ unset($data[$key]);}
            		}
            	} 
            }else{///单表插入   
            	foreach ($data as $key=>$val){ 
	                if(!in_array($key,$fields) || $val===null) {
	                    unset($data[$key]);
	                }elseif(MAGIC_QUOTES_GPC && is_string($val)){
	                    $data[$key] =   stripslashes($val);
	                } 
            	}
            }
        }  
        /// 创建完成对数据进行自动处理
        $this->autoOperation($data,$type); 
        /// 赋值当前数据对象
        $this->data =   $data;
        /// 返回创建的数据以供其他调用 
        return $data;
     }

    /// 自动表单令牌验证
    /// TODO  ajax无刷新多次提交暂不能满足
    public function autoCheckToken($data) {
        if(C('TOKEN_ON')){
        	$no_check_action = array('insert');
        	if (in_array(ACTION_NAME,$no_check_action)) {
        		return true;
        	}
            $name   = C('TOKEN_NAME');
            if(!isset($data[$name]) || !isset($_SESSION[$name])) { /// 令牌数据无效
                return false;
            }

            /// 令牌验证
            list($key,$value)  =  explode('_',$data[$name]);
            if($_SESSION[$name][$key] == $value) { /// 防止重复提交
                unset($_SESSION[$name][$key]); /// 验证完成销毁session
                return true;
            }
            /// 开启TOKEN重置
            if(C('TOKEN_RESET')) unset($_SESSION[$name][$key]);
            return false;
        }
        return true;
    }

    /**
     * 使用正则验证数据
     * @access public
     * @param string $value  要验证的数据
     * @param string $rule 验证规则
     * @return boolean
     */
    public function regex($value,$rule) {
        $validate = array(
            'require'=> '/.+/',
            'email' => '/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/',
            'url' => '/^http|https:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/',
            'currency' => '/^\d+(\.\d+)?$/',
            'number' => '/^\d+$/',
            'zip' => '/^\d{6}$/',
            'integer' => '/^[-\+]?\d+$/',
            'double' => '/^[-\+]?\d+(\.\d+)?$/',
            'english' => '/^[A-Za-z]+$/', 
            
            'pst_integer' => '/^[1-9]+\d*$/', /// 不含0的正整数
            'z_integer' => '/^[0-9]+\d*$/', /// 包含0的正整数
            'is_no' => '/^[0-9a-zA-Z]+$/',	///数字跟字母
            'date'	=>	'/^\d{4}-\d{1,2}-\d{1,2}$/',
            'money' => '/^([1-9](\d*)((\.\d+)?|(\,\d+)?)|(0{1}(\.|\,)(\d*[1-9]{1}\d*)))$/',
            'zmoney' => '/^([0-9](\d*)((\.\d+)?|(\,\d+)?)|(0{1}(\.|\,)(\d*[0-9]{1}\d*)))$/',
            'currency' => '/^\d+(\.\d+)?$/',
        ); 
        /// 检查是否有内置的正则表达式
        if(isset($validate[strtolower($rule)]))
            $rule   =   $validate[strtolower($rule)];
        return preg_match($rule,$value)===1;
    }

    /**
     * 自动表单处理
     * @access public
     * @param array $data 创建数据
     * @param string $type 创建类型
     * @return mixed
     */
    private function autoOperation(&$data,$type) {
        if(!empty($this->options['auto'])) {
            $_auto   =   $this->options['auto'];
            unset($this->options['auto']);
        }elseif(!empty($this->_auto)){
            $_auto   =   $this->_auto;
        }
        /// 自动填充
        if(isset($_auto)) {
            foreach ($_auto as $auto){
                /// 填充因子定义格式
                /// array('field','填充内容','填充条件','附加规则',[额外参数])
                if(empty($auto[2])) $auto[2] = self::MODEL_INSERT; /// 默认为新增的时候自动填充
                if( $type == $auto[2] || $auto[2] == self::MODEL_BOTH) {
                    switch($auto[3]) {
                        case 'function':    ///  使用函数进行填充 字段的值作为参数
                        case 'callback': /// 使用回调方法
                            $args = isset($auto[4])?(array)$auto[4]:array();
                            if(isset($data[$auto[0]])) {
                                array_unshift($args,$data[$auto[0]]);
                            }
                            if('function'==$auto[3]) {
                                $data[$auto[0]]  = call_user_func_array($auto[1], $args);
                            }else{
                                $data[$auto[0]]  =  call_user_func_array(array(&$this,$auto[1]), $args);
                            }
                            break;
                        case 'field':    /// 用其它字段的值进行填充
                            $data[$auto[0]] = $data[$auto[1]];
                            break;
                        case 'string':
                        default: /// 默认作为字符串填充
                            $data[$auto[0]] = $auto[1];
                    }
                    if(false === $data[$auto[0]] )   unset($data[$auto[0]]);
                }
            }
        }
        return $data;
    }

    /**
     * 自动表单验证
     * @access protected
     * @param array $data 创建数据
     * @param string $type 创建类型
     * @param string $type 验证数据的数组(lee)6-14
     * @return boolean
     */
    protected function autoValidation($data,$type,$_validate=array()) {  
    	if (empty($_validate)){
    		if(!empty($this->options['validate'])) {
            $_validate   =   $this->options['validate'];
            unset($this->options['validate']);
	        }elseif(!empty($this->_validate)){
	            $_validate   =   $this->_validate;
	        }
    	} 
        /// 属性验证
        if(isset($_validate)) { /// 如果设置了数据自动验证则进行数据验证
            if($this->patchValidate && empty($this->error)) { /// 重置验证错误信息
                $this->error = array();
            }
            foreach($_validate as $key=>$val) {
                /// 验证因子定义格式
                /// array(field,rule,message,condition,type,when,params)
                /// 判断是否需要执行验证
                if(empty($val[5]) || $val[5]== self::MODEL_BOTH || $val[5]== $type ) {
                    if(0==strpos($val[2],'{%') && strpos($val[2],'}'))
                        /// 支持提示信息的多语言 使用 {%语言定义} 方式
                        $val[2]  =  L(substr($val[2],2,-1));
                    $val[3]  =  isset($val[3])?$val[3]:self::EXISTS_VAILIDATE;
                    $val[4]  =  isset($val[4])?$val[4]:'regex'; 
                    /// 判断验证条件
                    switch($val[3]) {
                        case self::MUST_VALIDATE:   /// 必须验证 不管表单是否有设置该字段
                            if(false === $this->_validationField($data,$val)) 
                                return false;
                            break;
                        case self::VALUE_VAILIDATE:    /// 值不为空的时候才验证
                            if('' != trim($data[$val[0]]))
                                if(false === $this->_validationField($data,$val)) 
                                    return false;
                            break;
                        default:    /// 默认表单存在该字段就验证
                            if(isset($data[$val[0]]))
                                if(false === $this->_validationField($data,$val)) 
                                    return false;
                    }
                }
            }  
            /// 批量验证的时候最后返回错误 
            if(!empty($this->error)) {$this->errorStatus = 2;return false;}
        }  
        return true;
    }

    /**
     * 验证表单字段 支持批量验证
     * 如果批量验证返回错误的数组信息
     * @access protected
     * @param array $data 创建数据
     * @param array $val 验证因子
     * @return boolean
     */
    protected function _validationField($data,$val) {
        if(false === $this->_validationFieldItem($data,$val)){
            if($this->patchValidate) { 
            	if (!isset($this->error[$val[0]]) && !empty($val[2])){
            		$name	=	$val['id']?$val['id']:$val[0]; 
            		if (empty($name) || isset($this->errorHistory[$name])){ return ;}
            		$this->errorHistory[$name]	=	2;
            		$this->error[]	=  array('name'=>$name,'value'=>L($val[2]));
            	} 
            }else{
                $this->error    =   L($val[2]);
                return false;
            }
        }
        return ;
    }

    /**
     * 根据验证因子验证字段
     * @access protected
     * @param array $data 创建数据
     * @param array $val 验证因子
     * @return boolean
     */
    protected function _validationFieldItem($data,$val) {
        switch($val[4]) {
        	
        	case 'function':/// 使用函数进行验证
            case 'callback':/// 调用方法进行验证
            case 'valid':/// 调用方法进行验证
            case 'validDetail':/// 调用方法进行验证
            case 'callbacks':/// 调用方法进行验证
                $args = isset($val[6])?(array)$val[6]:array();
                if(is_string($val[0]) && strpos($val[0], ','))
                    $val[0] = explode(',', $val[0]);
                if(is_array($val[0])){
                    /// 支持多个字段验证
                    foreach($val[0] as $field)
                        $_data[$field] = $data[$field];
                    array_unshift($args, $_data);
                }else{
                    array_unshift($args, $data[$val[0]]);
                }
                switch ($val[4]){ 
		        	case 'function':/// 使用函数进行验证
		        		return call_user_func_array($val[1], $args);
		        	break;
		            case 'callback':/// 调用方法进行验证
		            	return call_user_func_array(array(&$this, $val[1]), $args);
		            break;
		            case 'callbacks':/// 调用方法进行验证  
			            $funDate['date']= array_merge($args,$data);
			            return $this->$val[1]($funDate['date']);
//	                    return call_user_func_array(array(&$this, $val[1]),$funDate);
		            break;
		            case 'valid':/// 调用方法进行验证   
			            $funDate['date']	= array_merge($args,$data);
			            $funDate['valid']	= $val[1]; 
			            return $this->_validSubmit($funDate['date'],$funDate['valid']);
//	                    return call_user_func_array(array(&$this, '_validSubmit'),$funDate);
		            break;
		            case 'validDetail':/// 调用方法进行验证 
			            $funDate['date']	= array_merge($args,$data);
			            $funDate['valid']	= $val[1]; 
			            					return $this->_validSubmitDetail($funDate['date'],$funDate['valid']);
			            					
//	                    return call_user_func_array(array(&$this, '_validSubmitDetail'),$funDate);
		            break;
                }  
            case 'confirm': /// 验证两个字段是否相同
                return $data[$val[0]] == $data[$val[1]];
            case 'unconfirm': /// 验证两个字段是否相同
            	if ($data[$val[0]] == $data[$val[1]]){
            		return false;
            	}else{
            		return true;
            	}
            case 'ifcheck' : /// 验证某个字段为某个值时验证某字段是否为空           
            	if ($data[$val[1]] == $val[6]) {
            		return $this->regex($data[$val[0]],'require');
            	}         
            	return true;  
            case 'bill_no' : /// 验证某个字段为某个值时验证某字段是否为空  
            	if (empty($data[$val[0]])){ return true; }
           		$where	=	' bill_no=\''.$data[$val[0]].'\' and to_hide=1 ';
            	$bill	=	M('bank_center')->where($where)->find();  
            	if (is_array($bill)){
            		return false;
            	}     
            	return true;  	 
            case 'gt': /// 大于某个值             	
            	return $data[$val[0]] > $data[$val[1]];
            case 'egtdate': /// 大于等于某个值    
            	return formatDate($data[$val[0]],'vf_date') >= formatDate($data[$val[1]],'vf_date');
 			case 'egt': /// 大于等于某个值  
            	return $data[$val[0]] >= $data[$val[1]];            	
            case 'lt': /// 小于某个值            	
            	return $data[$val[0]] < $data[$val[1]];
            case 'elt': /// 小于等于某个值
            	return $data[$val[0]] <= $data[$val[1]];		
            /// end 邹燕娟 2011-04-07     
            case 'unique': /// 验证某个值是否唯一
                if(is_string($val[0]) && strpos($val[0],','))
                    $val[0]  =  explode(',',$val[0]);
                $map = array();
                if(is_array($val[0])) {
                    /// 支持多个字段验证
                    foreach ($val[0] as $field)
                        $map[$field]   =  $data[$field];
                }else{
                    $map[$val[0]] = $data[$val[0]];
                }
                /// 加上自定义验证条件
              	isset($val[6]) && !empty($val[6]) &&  $map = array_merge($map,$val[6]);
                if(!empty($data[$this->getPk()])) { /// 完善编辑的时候验证唯一
                    $map[$this->getPk()] = array('neq',$data[$this->getPk()]);
                }
                $rs	= $this->field($this->getPk())->where($map)->find();
                $this->excel_ids	= $rs;
                 if ($this->valid_excel_unique_state==false){
                	return true;
                }   
                if(is_array($rs)){
                	 return false;
                } 
                return true;
             case 'uniquenoempty': /// 验证某个值是否唯一
                if(is_string($val[0]) && strpos($val[0],','))
                    $val[0]  =  explode(',',$val[0]);
                $map = array();
                if(is_array($val[0])) {
                    /// 支持多个字段验证
                    foreach ($val[0] as $field)
                        $map[$field]   =  $data[$field];
                }else{
                    $map[$val[0]] = trim($data[$val[0]]);
                }
                if ($map[$val[0]]=='') {
                	return true;
                }
                /// 加上自定义验证条件
              	isset($val[6]) && !empty($val[6]) &&  $map = array_merge($map,$val[6]);
                if(!empty($data[$this->getPk()])) { /// 完善编辑的时候验证唯一
                    $map[$this->getPk()] = array('neq',$data[$this->getPk()]);
                }
                $rs	= $this->field($this->getPk())->where($map)->find();
                $this->excel_ids	= $rs;
                 if ($this->valid_excel_unique_state==false){
                	return true;
                }   
                if(is_array($rs)){
                	 return false;
                } 
                return true;
            /// 李恺弘 2011-05-07 
            case 'unique_sp': /// 验证某个值是否唯一    
            	        	
                if(is_string($val[0]) && strpos($val[0],','))
                    $val[0]  =  explode(',',$val[0]);
                $map = array();
                if(is_array($val[0])) {
                    /// 支持多个字段验证
                    foreach ($val[0] as $field)
                        $map[$field]   =  $data[$field];
                }else{
                    $map[$val[0]] = $data[$val[0]];
                }
                /// 加上自定义验证条件
              	isset($val[6]) && !empty($val[6]) &&  $map = array_merge($map,$val[6]);
                if(!empty($data[$this->getPk()])) { /// 完善编辑的时候验证唯一
                    $map[$this->getPk()] = array('neq',$data[$this->getPk()]);
                }
                $this->options['disdatawhere'] = true;               
                foreach ($map as $key=>$value) {
                	if (empty($value)) {
                		return true;
                	}
                } 
                if($this->where($map)->find())
                    return false; 
                break;     
            default:  /// 检查附加规则
                return $this->check($data[$val[0]],$val[1],$val[4]);
        }
    }

    /**
     * 验证数据 支持 in between equal length regex expire ip_allow ip_deny
     * @access public
     * @param string $value 验证数据
     * @param mixed $rule 验证表达式
     * @param string $type 验证方式 默认为正则验证
     * @return boolean
     */
    public function check($value,$rule,$type='regex'){
        switch(strtolower($type)) {
            case 'in': /// 验证是否在某个指定范围之内 逗号分隔字符串或者数组
                $range   = is_array($rule)?$rule:explode(',',$rule);
                return in_array($value ,$range);
            case 'between': /// 验证是否在某个范围
                if (is_array($rule)){
                    $min    =    $rule[0];
                    $max    =    $rule[1];
                }else{
                    list($min,$max)   =  explode(',',$rule);
                }
                return $value>=$min && $value<=$max;
            case 'equal': /// 验证是否等于某个值
                return $value == $rule;
            case 'length': /// 验证长度
                $length  =  mb_strlen($value,'utf-8'); /// 当前数据长度
                if(strpos($rule,',')) { /// 长度区间
                    list($min,$max)   =  explode(',',$rule);
                    return $length >= $min && $length <= $max;
                }else{/// 指定长度
                    return $length == $rule;
                }
            case 'expire':
                list($start,$end)   =  explode(',',$rule);
                if(!is_numeric($start)) $start   =  strtotime($start);
                if(!is_numeric($end)) $end   =  strtotime($end);
                return $_SERVER['REQUEST_TIME'] >= $start && $_SERVER['REQUEST_TIME'] <= $end;
            case 'ip_allow': /// IP 操作许可验证
                return in_array(get_client_ip(),explode(',',$rule));
            case 'ip_deny': /// IP 操作禁止验证
                return !in_array(get_client_ip(),explode(',',$rule));
            case 'regex':
            default:    /// 默认使用正则验证 可以使用验证类中定义的验证名称
                /// 检查附加规则
                return $this->regex($value,$rule);
        }
    }

    /**
     * SQL查询
     * @access public
     * @param mixed $sql  SQL指令
     * @param boolean $parse  是否需要解析SQL
     * @return mixed
     */
    public function query($sql,$parse=false) {
        $sql  =   $this->parseSql($sql,$parse);
        $cache  =  isset($this->options['cache'])?$this->options['cache']:false;
        if($cache && C('QUERY_CACHE')) { /// 查询缓存检测
            $key 		=  is_string($cache['key'])?$cache['key']:md5($sql);
            $value   	=  S($key);
            if(false !== $value) {
                return $value;
            }
        }
        $result = $this->db->query($sql);
        if($cache && false !== $result ) { /// 查询缓存写入
            S($key,$result,$cache['expire'],$cache['type']);
        }
        return $result;
    }

    /**
     * SQL查询，返回二维数组中的第一维
     * @access public
     * @param mixed $sql  SQL指令
     * @param boolean $parse  是否需要解析SQL
     * @return  array
     */
    public function queryOne($sql,$parse=false) {
        $info = $this->query($sql,$parse);
        return $info[0];
    }
    
     /**
     * SQL查询，返回指定字段值
     * @access public
     * @param mixed $sql  SQL指令
     * @param mstring$field 字段名
     * @param boolean $parse  是否需要解析SQL
     * @return string
     */
    public function queryField($sql,$field='count',$parse=false) {
       	$info = $this->queryOne($sql,$parse);
        return $info[$field];
    }
      
    
    /**
     * SQL查询，单字段查询时返回字条串
     * @access public
     * @param mixed $sql  SQL指令
     * @param mstring$depr  分隔符
     * @param boolean $parse  是否需要解析SQL
     * @return string
     */
    public function queryFieldStr($sql,$depr=',',$parse=false) {
        $info = $this->query($sql,$parse);
        foreach ((array)$info as $value) {
			$ids[] = $value['id'];
		}
		return implode($depr,$ids);
    }
    
    /**
     * 执行SQL语句
     * @access public
     * @param string $sql  SQL指令
     * @param boolean $parse  是否需要解析SQL
     * @return false | integer
     */
    public function execute($sql,$parse=false) {
        $sql  =   $this->parseSql($sql,$parse);
        return $this->db->execute($sql);
    }

    /**
     * 解析SQL语句
     * @access public
     * @param string $sql  SQL指令
     * @param boolean $parse  是否需要解析SQL
     * @return string
     */
    protected function parseSql($sql,$parse) {
        /// 分析表达式
        if($parse) {
            $options =  $this->_parseOptions();
            $sql  =   $this->db->parseSql($sql,$options);
        }else{
            if(strpos($sql,'__TABLE__'))
                $sql    =   str_replace('__TABLE__',$this->getTableName(),$sql);
        }
        $this->db->setModel($this->name);
        return $sql;
    }

    /**
     * 切换当前的数据库连接
     * @access public
     * @param integer $linkNum  连接序号
     * @param mixed $config  数据库连接信息
     * @param array $params  模型参数
     * @return Model
     */
    public function db($linkNum='',$config='',$params=array()){
        if(''===$linkNum && $this->db) {
            return $this->db;
        }
        static $_linkNum    =   array();
        static $_db = array();
        if(!isset($_db[$linkNum]) || (isset($_db[$linkNum]) && $_linkNum[$linkNum]!=$config) ) {
            /// 创建一个新的实例
            if(!empty($config) && is_string($config) && false === strpos($config,'/')) { /// 支持读取配置参数
                $config  =  C($config);
            }
            $_db[$linkNum]            =    Db::getInstance($config);
        }elseif(NULL === $config){
            $_db[$linkNum]->close(); /// 关闭数据库连接
            unset($_db[$linkNum]);
            return ;
        }
        if(!empty($params)) {
            if(is_string($params))    parse_str($params,$params);
            foreach ($params as $name=>$value){
                $this->setProperty($name,$value);
            }
        }
        /// 记录连接信息
        $_linkNum[$linkNum] =   $config;
        /// 切换数据库连接
        $this->db   =    $_db[$linkNum];
        $this->_after_db();
        /// 字段检测
        if(!empty($this->name) && $this->autoCheckFields)    $this->_checkTableInfo();
        return $this;
    }
    /// 数据库切换后回调方法
    protected function _after_db() {}

    /**
     * 得到当前的数据对象名称
     * @access public
     * @return string
     */
    public function getModelName() {
        if(empty($this->name))
            $this->name =   substr(get_class($this),0,-5);
        return $this->name;
    }

    /**
     * 得到完整的数据表名
     * @access public
     * @return string
     */
    public function getTableName() {
        if(empty($this->trueTableName)) {
            $tableName  = !empty($this->tablePrefix) ? $this->tablePrefix : '';
            if(!empty($this->tableName)) {
                $tableName .= $this->tableName;
            }else{
                $tableName .= parse_name($this->name);
            }
            $this->trueTableName    =   strtolower($tableName);
        }
        return (!empty($this->dbName)?$this->dbName.'.':'').$this->trueTableName;
    }

    /**
     * 启动事务
     * @access public
     * @return void
     */
    public function startTrans() {
        $this->commit();
        $this->db->startTrans();
        return ;
    }

    /**
     * 提交事务
     * @access public
     * @return boolean
     */
    public function commit() {
        return $this->db->commit();
    }

    /**
     * 事务回滚
     * @access public
     * @return boolean
     */
    public function rollback() {
        return $this->db->rollback();
    }

    /**
     * 返回模型的错误信息
     * @access public
     * @return string
     */
    public function getError(){  
    	///if (is_array($this->error)){ $this->error	=	json_encode($this->error); }///lee 
        return $this->error;
    }
    
    /**
     * 返回模型的错误信息
     * @access public
     * @return string
     */
    public function addError($error){
    	foreach ($error as $k=>$v){
    		$this->error[$k]	=	$v;
    	} 
    }

    /**
     * 返回数据库的错误信息
     * @access public
     * @return string
     */
    public function getDbError() {
        return $this->db->getError();
    }

    /**
     * 返回最后插入的ID
     * @access public
     * @return string
     */
    public function getLastInsID() {
        return $this->db->getLastInsID();
    }

    /**
     * 返回最后执行的sql语句
     * @access public
     * @return string
     */
    public function getLastSql() {
        return $this->db->getLastSql($this->name);
    }
    /// 鉴于getLastSql比较常用 增加_sql 别名
    public function _sql(){
        return $this->getLastSql();
    }

    /**
     * 获取主键名称
     * @access public
     * @return string
     */
    public function getPk() {
        return isset($this->fields['_pk'])?$this->fields['_pk']:$this->pk;
    }

    /**
     * 获取数据表字段信息
     * @access public
     * @return array
     */
    public function getDbFields(){
        if($this->fields) {
            $fields   =  $this->fields;
            unset($fields['_autoinc'],$fields['_pk'],$fields['_type'],$fields['_version']);
            unset($fields['_autoinc'],$fields['_pk'],$fields['_type']);
            return $fields;
        }
        return false;
    }

    /**
     * 设置数据对象值
     * @access public
     * @param mixed $data 数据
     * @return Model
     */
    public function data($data=''){
        if('' === $data && !empty($this->data)) {
            return $this->data;
        }
        if(is_object($data)){
            $data   =   get_object_vars($data);
        }elseif(is_string($data)){
            parse_str($data,$data);
        }elseif(!is_array($data)){
            throw_exception(L('_DATA_TYPE_INVALID_'));
        }
        $this->data = $data;
        return $this;
    }

    /**
     * 查询SQL组装 join
     * @access public
     * @param mixed $join
     * @return Model
     */
    public function join($join) {
        if(is_array($join)) {
            $this->options['join'] =  $join;
        }elseif(!empty($join)) {
            $this->options['join'][]  =   $join;
        }
        return $this;
    }

    /**
     * 查询SQL组装 union
     * @access public
     * @param mixed $union
     * @param boolean $all
     * @return Model
     */
    public function union($union,$all=false) {
        if(empty($union)) return $this;
        if($all) {
            $this->options['union']['_all']  =   true;
        }
        if(is_object($union)) {
            $union   =  get_object_vars($union);
        }
        /// 转换union表达式
        if(is_string($union) ) {
            $options =  $union;
        }elseif(is_array($union)){
            if(isset($union[0])) {
                $this->options['union']  =  array_merge($this->options['union'],$union);
                return $this;
            }else{
                $options =  $union;
            }
        }else{
            throw_exception(L('_DATA_TYPE_INVALID_'));
        }
        $this->options['union'][]  =   $options;
        return $this;
    }

    /**
     * 查询缓存
     * @access public
     * @param mixed $key
     * @param integer $expire
     * @param string $type
     * @return Model
     */
    public function cache($expire='60',$key=true,$type=''){
        $this->options['cache']  =  array('key'=>$key,'expire'=>$expire,'type'=>$type);
        return $this;
    }

    /**
     * 指定查询字段 支持字段排除
     * @access public
     * @param mixed $field
     * @param boolean $except 是否排除
     * @return Model
     */
    public function field($field,$except=false){
        if(true === $field) {/// 获取全部字段
            $fields   =  $this->getDbFields();
            $field =  $fields?$fields:'*';
        }elseif($except) {/// 字段排除
            if(is_string($field)) {
                $field =  explode(',',$field);
            }
            $fields   =  $this->getDbFields();
            $field =  $fields?array_diff($fields,$field):$field;
        }
        $this->options['field']   =   $field;
        return $this;
    }

    /**
     * 调用命名范围
     * @access public
     * @param mixed $scope 命名范围名称 支持多个 和直接定义
     * @param array $args 参数
     * @return Model
     */
    public function scope($scope='',$args=NULL){
        if('' === $scope) {
            if(isset($this->_scope['default'])) {
                /// 默认的命名范围
                $options    =   $this->_scope['default'];
            }else{
                return $this;
            }
        }elseif(is_string($scope)){ /// 支持多个命名范围调用 用逗号分割
            $scopes    =   explode(',',$scope);
            $options    =   array();
            foreach ($scopes as $name){
                if(!isset($this->_scope[$name])) continue;
                $options    =   array_merge($options,$this->_scope[$name]);
            }
            if(!empty($args) && is_array($args)) {
                $options    =   array_merge($options,$args);
            }
        }elseif(is_array($scope)){ /// 直接传入命名范围定义
            $options    =   $scope;
        }
        
        if(is_array($options) && !empty($options)){
            $this->options  =   array_merge($this->options,array_change_key_case($options));
        }
        return $this;
    }

    /**
     * 设置模型的属性值
     * @access public
     * @param string $name 名称
     * @param mixed $value 值
     * @return Model
     */
    public function setProperty($name,$value) {
        if(property_exists($this,$name))
            $this->$name = $value;
        return $this;
    }
    
    
    /**
     * 表单单表验证
     *
     * @param unknown_type $data
     * @return unknown
     */
    public function _validSubmit(&$data,&$_moduleValidate='_moduleValidate'){
        $data=empty($data['date'])?$data:$data['date'];
		return $this->_moduleValidation(&$this,&$data,&$_moduleValidate);  
	}
	
	/**
     * 表单明细表验证
     *
     * @param unknown_type $data
     * @return bool
     */
    public function _validSubmitDetail(&$data,&$_moduleValidate='_moduleValidate'){     
		return $this->_moduleValidationDetail(&$this,&$data,'detail',&$_moduleValidate);  
	}
	
	
    
    /**
	 * 模块表单一维数组验证
	 *
	 * @param unknown_type $model 	模块
	 * @param unknown_type $data	验证的数据
	 * @param unknown_type $_moduleValidate	验证数据对应的数组(可以是模块内的下标数组 或者直接给数组)
	 * @return unknown
	 */
	public function _moduleValidation(&$model,&$data,$_moduleValidate='_moduleValidate'){  
		if (!is_object($model) || empty($data)){ return true;} 
		$valid	=	is_array($_moduleValidate)?$_moduleValidate:$model->$_moduleValidate;    
		if (!is_array($valid)){ return true; }   
		return  $this->autoValidation(&$data,$this->_valid_type,&$valid);    
	}
	
	/**
	 * 模块表单二维数组验证
	 *
	 * @param unknown_type $model 模型
	 * @param unknown_type $data  验证的数据
	 * @param unknown_type $dateKey 二维下标
	 * @param unknown_type $_moduleValidate 验证数组
	 */
	public function _moduleValidationDetail(&$model,&$data,$dateKey='detail',$_moduleValidate='_moduleValidateDetail'){   
		$state				=	true;  
		$data				=	$this->_validBeforDate(&$data,$dateKey);///数据验证之前处理的条件判断 一般由流程module自己行完成  
		$_moduleValidate	=	is_array($_moduleValidate)?$_moduleValidate:$model->$_moduleValidate; ///获取验证规则  
		if (!is_array($_moduleValidate) || !is_array($data[$dateKey])){ return $state; } 
		foreach ((array)$data[$dateKey] as $key=>$value){ ///循环验证明细 
			$id				=	$dateKey.'['.$key.']';
			$validArray		=	$this->_setValidDetailName(&$_moduleValidate,&$id); ///设置提示的错误的ID
			if ($this->_moduleValidation(&$model,$value,$validArray)===false){ 
				$state		=	false; ///如果任意一条false则返回false.
			} 
		}
		return $state; 
	}
	
	/**
	 * 二维的ID重新处理提示的id
	 *
	 * @param unknown_type $array
	 * @param unknown_type $id
	 * @return unknown
	 */
	public function _setValidDetailName(&$array,&$id){ 
		foreach ((array)$array as $key=>$value){
			$array[$key]['id']	=	$id.'['.$value[0].']'; 
		}  
		return $array;
	}
	
	/**
	 * 数据验证之前处理的条件判断 一般由流程module自己行完成 
	 * 默认直接返回
	 *
	 * @param unknown_type $date
	 * @return unknown
	 */
	public function _validBeforDate(&$date){
		return $date;
	}
	
	 /**
     * 查询数据集(根据参数中的key对数组进行格式化,最多支持两级)
     * @access public
     * @param array $options 表达式参数
     * @return mixed
     */
    public function formatFindAll($options=array()) {   
    	$format_key 		= $options['key'];										/// 返回数组的key
    	$format_value_key 	= $options['v_key'] ; 									/// 返回数组值的key
    	$fun_name			= $options['fun'];										/// 格式化的函数名
    	unset($options['key'],$options['v_key']) ;    	
    	$result = $this->select($options);
    	return formatArray($result, $format_key, $format_value_key );	/// 调用格式化函数(functions.php)
    }  
    
    /**
     * 跨模块调用时需要重定义模块及操作值
     * 
     */
    public function setModuleInfo($module,$action){
    	$this->_module = $module;
    	$this->_action = $action;
    }

    /**
     * 记录乐观锁
     * @access protected
     * @param array $data 数据对象
     * @return array
     */
    public function recordLockVersion($data) {
        /// 记录乐观锁
        if(C('LOCK_ON') && !isset($data[C('LOCK_NAME')]) ) {
            if(in_array(C('LOCK_NAME'),$this->fields,true)) {
                $data[$this->optimLock]  =   0;
            }
        }
        return $data;
    }
    
    /**
     * 缓存乐观锁
     * @access protected
     * @param array $data 数据对象
     * @return void
     */
    public function cacheLockVersion($data) {
        if(C('LOCK_ON')) {
            if(isset($data[C('LOCK_NAME')]) && isset($data[$this->getPk()])) {
                /// 只有当存在乐观锁字段和主键有值的时候才记录乐观锁
                $_SESSION[MODULE_NAME.'_'.$data[$this->getPk()].'_lock_version']    =   $data[C('LOCK_NAME')];
            }
        }
    }

    /**
     * 检查乐观锁
     * @access protected
     * @param array $data  当前数据
     * @param array $options 查询表达式
     * @return mixed
     */
    protected function checkLockVersion(&$data,$vo=null) {
        $id = $data[$this->getPk()];
        /// 检查乐观锁
        $identify   = MODULE_NAME.'_'.$id.'_lock_version';
        if(C('LOCK_ON') && isset($_SESSION[$identify]) && in_array(C('LOCK_NAME'),$this->fields,true)) {
            $lock_version = $_SESSION[$identify];
            $vo==null && $vo =  $this->field(C('LOCK_NAME'))->find($id);
            $_SESSION[$identify]     =   $lock_version;
            $curr_version = $vo[C('LOCK_NAME')];
            if(isset($curr_version)) {
                if($curr_version>0 && $lock_version != $curr_version) {
                    /// 记录已经更新
                    $this->error = L('_RECORD_HAS_UPDATE_');
                    return false;
                }else{
                    /// 更新乐观锁
                    $save_version = $data[C('LOCK_NAME')];
                    if($save_version != $lock_version+1) {
                        $data[C('LOCK_NAME')]  =   $lock_version+1;
                    }
                    $_SESSION[$identify]     =   $lock_version+1;
                }
            }
        }
        return true;
    }
    
     /**
	 * 条形码验证
	 *
	 * @param unknown_type $data
	 */
	public function validbarcode($data){    
		$field_name_array	=	array(
								'Product'	=>'product_no',
								'Color'		=>'color_no',
								'Size'		=>'size_no', 
								'Factory'	=>'comp_no', 
								'ProductClass'	=>'class_no', 
								);
		$field_name		= $field_name_array[MODULE_NAME];  						
		$length			= getBarcodeLen($field_name);   ///配置最大的长度 
		
		///判断长度是否可变
		if (getBarcodeExchange($field_name)){ 
			if (strlen($data[$field_name])>$length){
				$is_exchange	= true;
			}else{
				$is_exchange	= false;
			}  
		}else{
			$is_exchange	= true;
		} 
		
		if ($length>0 && $is_exchange){
			$valid	 =	 array(
				array($field_name,$length,L('barcode_length').$length.L('place'),2,'length'),	/// 验证长度－条形码
			);  
			$this->_validSubmit(&$data,$valid);     
		}
	}
	
	
	public function getValidDate(){
		return $this->_validate;
	}
	
	
	public function setLog($log,$id){
		return $log;
	}
	
	/**
	 * 获取日志记录信息
	 *
	 */
	public function insertLog($id){
		if(empty($id)) return ;
		$table_name = $this->trueTableName;
		$log = '';
		switch (ACTION_NAME) {
			case 'insert':
				$log = L('add');
				$rs = $this->find($id);
				break;
			case 'update':
				$log = L('update');
				$rs = $this->find($id);
				break;
			case 'delete':
				$tables = M()->db->getTables(C('DB_NAME'));
				if (in_array($table_name.'_del',$tables)) {
					$log = $_GET['restore'] ? L('restore') : L('delete');
					$rs = M($table_name.'_del')->find($id);
				}else {
					$log = $_GET['restore'] ? L('restore') : L('cancel');
					$rs = M($table_name)->find($id);
				}
				break;
			case 'setFinishDetailState':
				$log = $_GET['type']==1 ? L('manual_finished') : L('un_manual_finished');
				$temp = M('OrderDetails')->field('orders_id')->find($id);
				$rs = $this->find($temp['orders_id']);
				break;	
			case 'resetPasswd':
				$log = L('reset').L('user_pwd');
				$rs = M($table_name)->find($id);
			default:
				break;
		}
		$log .= L('module_'.MODULE_NAME).'，';
		$name_field	= $table_name.'_name';
		switch (MODULE_NAME) {
			case 'Orders':
				$no_field	= 'order_no';
				break;
			case 'InvoiceIn':
				$no_field	= 'invoice_no';
				break;
			case 'InvoiceOut':
				$no_field	= 'invoice_no';
				break;
			case 'InvoiceInitStorage':
				$no_field	= 'init_no';
				break;
			case 'Client':
			case 'Factory':
			case 'Logistics':
			case 'OtherCompany':
				$name_field	= 'comp_name';
				break;
			case 'Warehouse':
				$name_field	= 'w_name';
				break;
			case 'InvoiceSupplier':
			case 'InvoiceClient':
			case 'InvoiceCompany':
				$name_field	= 'company_name';
				break;
			case 'InvoiceProduct':
				$name_field	= 'product_name';
				break;
			case 'ProductClass':
				$name_field	= 'class_name';
				$no_field	= 'class_no';
				break;
			case 'PropertiesValue':
				$name_field	= 'pv_no';
				$no_field	= 'pv_name';
				break;
			default:
				$no_field	= $table_name.'_no';
				$name_field	= $table_name.'_name';
				break;
		}
		if ($rs[$no_field]) {
			$log .= L('code').'：'. $rs[$no_field].'；';
		}
		if ($rs[$name_field]) {
			$log .= L('name').'：'. $rs[$name_field].'；';
		}
		$log = $this->setLog($log,$id);
		$log_ary = array('module'=>MODULE_NAME,'action'=>ACTION_NAME,'user_id'=>getUser('id'),'content'=>$log,'ip'=>get_client_ip(),'insert_time'=>date("Y-m-d H:i:s"));
		M('Log')->add($log_ary);
	}
}













